{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.callbacks import LearningRateScheduler\n",
    "import seaborn as sns\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import models\n",
    "\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "import xgboost as xgb\n",
    "import lightgbm as lgb\n",
    "from catboost import CatBoostClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num GPUs Available:  0\n"
     ]
    }
   ],
   "source": [
    "print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_error_matrix(y_test,y_pred):\n",
    "    confusion_mtx = tf.math.confusion_matrix(y_test, y_pred)\n",
    "    plt.figure(figsize=(10, 8))\n",
    "    sns.heatmap(confusion_mtx,\n",
    "                annot=True, fmt='g',\n",
    "                cmap='coolwarm')\n",
    "    plt.xlabel('Prediction')\n",
    "    plt.ylabel('True')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_ROC(fpr,tpr,roc_auc):\n",
    "    plt.figure()\n",
    "    plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (AUC = {roc_auc:.2f})')\n",
    "    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--') \n",
    "    plt.xlim([0.0, 1.0])\n",
    "    plt.ylim([0.0, 1.05])\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title('Receiver Operating Characteristic (ROC)')\n",
    "    plt.legend(loc=\"lower right\")\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "def specificity_score(y_true, y_pred):\n",
    "    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n",
    "    return tn / (tn + fp) if (tn + fp) > 0 else 0\n",
    "\n",
    "def evaluate_model_on_folds(model, folds=5, prefix=\"data/fold_\",scaler=\"MinMaxScaler\"):\n",
    "    metrics = {\n",
    "        'acc': [],\n",
    "        'f1': [],\n",
    "        'precision': [],\n",
    "        'recall': [],\n",
    "        'specificity': []\n",
    "    }\n",
    "\n",
    "    for i in range(folds):\n",
    "        train = pd.read_csv(f\"{prefix}{i+1}_train.csv\")\n",
    "        test = pd.read_csv(f\"{prefix}{i+1}_test.csv\")\n",
    "        \n",
    "        \n",
    "\n",
    "        if scaler==\"MinMaxScaler\":\n",
    "            test['arrytmia'] = test['arrytmia'].apply(lambda x: 1 if x > 1 else x)\n",
    "            train['arrytmia'] = train['arrytmia'].apply(lambda x: 1 if x > 1 else x)\n",
    "            scaler = MinMaxScaler()\n",
    "            train = pd.DataFrame(scaler.fit_transform(train), columns=train.columns)\n",
    "            test = pd.DataFrame(scaler.transform(test), columns=test.columns)\n",
    "\n",
    "            X_train = train.iloc[:, 1:].values\n",
    "            y_train = train['arrytmia'].values\n",
    "\n",
    "            X_test = test.iloc[:, 1:].values\n",
    "            y_test = test['arrytmia'].values\n",
    "        else:\n",
    "            # Przekształcenie kolumny 'arrytmia'\n",
    "            test['arrytmia'] = test['arrytmia'].apply(lambda x: 1 if x > 1 else x)\n",
    "            train['arrytmia'] = train['arrytmia'].apply(lambda x: 1 if x > 1 else x)\n",
    "\n",
    "            test['arrytmia'] = test['arrytmia'].apply(lambda x: -1 if x == 0 else x)\n",
    "            train['arrytmia'] = train['arrytmia'].apply(lambda x: -1 if x == 0 else x)\n",
    "\n",
    "            # Przygotowanie danych\n",
    "            X_train = train.iloc[:, 1:]\n",
    "            y_train = train['arrytmia'].values\n",
    "\n",
    "            X_test = test.iloc[:, 1:]\n",
    "            y_test = test['arrytmia'].values\n",
    "\n",
    "            # Normalizacja\n",
    "            scaler = StandardScaler()\n",
    "            X_train = pd.DataFrame(scaler.fit_transform(X_train), columns=X_train.columns)\n",
    "            X_test = pd.DataFrame(scaler.transform(X_test), columns=X_test.columns)\n",
    "        \n",
    "\n",
    "        model.fit(X_train, y_train)\n",
    "        y_pred = model.predict(X_test)\n",
    "        \n",
    "        cm = confusion_matrix(y_test, y_pred)\n",
    "        tn, fp, fn, tp = cm.ravel()\n",
    "\n",
    "        acc = (tp + tn) / (tp + tn + fp + fn) if (tp + tn + fp + fn) > 0 else 0\n",
    "        precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n",
    "        recall = tp / (tp + fn) if (tp + fn) > 0 else 0\n",
    "        specificity = tn / (tn + fp) if (tn + fp) > 0 else 0\n",
    "        f1 = 2 * tp / (2 * tp + fp + fn) if (2 * tp + fp + fn) > 0 else 0\n",
    "\n",
    "        metrics['acc'].append(acc)\n",
    "        metrics['f1'].append(f1)\n",
    "        metrics['precision'].append(precision)\n",
    "        metrics['recall'].append(recall)\n",
    "        metrics['specificity'].append(specificity)\n",
    "\n",
    "    def mean_std_str(metric_list):\n",
    "        mean = np.mean(metric_list)\n",
    "        std = np.std(metric_list)\n",
    "        return f\"{mean:.4f} ± {std:.4f}\"\n",
    "\n",
    "    print(f\"Accuracy:     {mean_std_str(metrics['acc'])}\")\n",
    "    print(f\"F1:           {mean_std_str(metrics['f1'])}\")\n",
    "    print(f\"Precision:    {mean_std_str(metrics['precision'])}\")\n",
    "    print(f\"Sensitivity:  {mean_std_str(metrics['recall'])}\")\n",
    "    print(f\"Specificity:  {mean_std_str(metrics['specificity'])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.8313 ± 0.0098\n",
      "F1:           0.8649 ± 0.0066\n",
      "Precision:    0.8401 ± 0.0136\n",
      "Sensitivity:  0.8913 ± 0.0025\n",
      "Specificity:  0.7394 ± 0.0266\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=50)\n",
    "evaluate_model_on_folds(knn)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DecisionTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.8277 ± 0.0105\n",
      "F1:           0.8591 ± 0.0080\n",
      "Precision:    0.8506 ± 0.0111\n",
      "Sensitivity:  0.8679 ± 0.0065\n",
      "Specificity:  0.7661 ± 0.0196\n"
     ]
    }
   ],
   "source": [
    "Dtree = DecisionTreeClassifier(max_depth=30)  \n",
    "evaluate_model_on_folds(Dtree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RandomForest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.6853 ± 0.0071\n",
      "F1:           0.7872 ± 0.0050\n",
      "Precision:    0.6664 ± 0.0050\n",
      "Sensitivity:  0.9614 ± 0.0061\n",
      "Specificity:  0.2618 ± 0.0118\n"
     ]
    }
   ],
   "source": [
    "Rforest = RandomForestClassifier(n_estimators=100, max_depth=3, random_state=42)\n",
    "evaluate_model_on_folds(Rforest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SVM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## klasyfikator Naive Bayes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.4279 ± 0.0075\n",
      "F1:           0.2175 ± 0.0361\n",
      "Precision:    0.6366 ± 0.0389\n",
      "Sensitivity:  0.1324 ± 0.0256\n",
      "Specificity:  0.8812 ± 0.0330\n"
     ]
    }
   ],
   "source": [
    "NBayes = GaussianNB()\n",
    "evaluate_model_on_folds(NBayes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XGBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.8598 ± 0.0113\n",
      "F1:           0.8855 ± 0.0086\n",
      "Precision:    0.8764 ± 0.0129\n",
      "Sensitivity:  0.8947 ± 0.0050\n",
      "Specificity:  0.8063 ± 0.0224\n"
     ]
    }
   ],
   "source": [
    "XGBoost = xgb.XGBClassifier()\n",
    "evaluate_model_on_folds(XGBoost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LightGBM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Kuba\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\utils\\validation.py:2739: UserWarning: X does not have valid feature names, but LGBMClassifier was fitted with feature names\n",
      "  warnings.warn(\n",
      "c:\\Users\\Kuba\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\utils\\validation.py:2739: UserWarning: X does not have valid feature names, but LGBMClassifier was fitted with feature names\n",
      "  warnings.warn(\n",
      "c:\\Users\\Kuba\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\utils\\validation.py:2739: UserWarning: X does not have valid feature names, but LGBMClassifier was fitted with feature names\n",
      "  warnings.warn(\n",
      "c:\\Users\\Kuba\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\utils\\validation.py:2739: UserWarning: X does not have valid feature names, but LGBMClassifier was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.8411 ± 0.0108\n",
      "F1:           0.8719 ± 0.0077\n",
      "Precision:    0.8519 ± 0.0135\n",
      "Sensitivity:  0.8930 ± 0.0036\n",
      "Specificity:  0.7614 ± 0.0254\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Kuba\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\utils\\validation.py:2739: UserWarning: X does not have valid feature names, but LGBMClassifier was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "LightGBM = lgb.LGBMClassifier(verbose=-1)\n",
    "evaluate_model_on_folds(LightGBM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CatBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.8568 ± 0.0107\n",
      "F1:           0.8832 ± 0.0081\n",
      "Precision:    0.8726 ± 0.0130\n",
      "Sensitivity:  0.8943 ± 0.0049\n",
      "Specificity:  0.7994 ± 0.0229\n"
     ]
    }
   ],
   "source": [
    "CatB = CatBoostClassifier(verbose=0)\n",
    "evaluate_model_on_folds(CatB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_given_keras_model(model_builder, scheduler=None, folds=5, prefix=\"data/fold_\", epochs=10, batch_size=32, thresholds=[0.5]):\n",
    "    from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score, matthews_corrcoef\n",
    "\n",
    "    auc_scores = []\n",
    "    all_y_true = []\n",
    "    all_y_pred_prob = []\n",
    "    mean_fpr = np.linspace(0, 1, 100)\n",
    "    tprs = []\n",
    "\n",
    "    for i in range(folds):\n",
    "        train = pd.read_csv(f\"{prefix}{i+1}_train.csv\")\n",
    "        test = pd.read_csv(f\"{prefix}{i+1}_test.csv\")\n",
    "\n",
    "        train['arrytmia'] = train['arrytmia'].apply(lambda x: 1 if x > 1 else x)\n",
    "        test['arrytmia'] = test['arrytmia'].apply(lambda x: 1 if x > 1 else x)\n",
    "\n",
    "        scaler = MinMaxScaler()\n",
    "        train = pd.DataFrame(scaler.fit_transform(train), columns=train.columns)\n",
    "        test = pd.DataFrame(scaler.transform(test), columns=test.columns)\n",
    "\n",
    "        X_train = train.iloc[:, 1:].values\n",
    "        y_train = train['arrytmia'].values\n",
    "\n",
    "        X_test = test.iloc[:, 1:].values\n",
    "        y_test = test['arrytmia'].values\n",
    "\n",
    "        model = model_builder(X_train.shape[1])\n",
    "        callbacks = [scheduler] if scheduler else []\n",
    "\n",
    "        model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size,\n",
    "                  verbose=0, callbacks=callbacks)\n",
    "\n",
    "        y_pred_prob = model.predict(X_test).ravel()\n",
    "        all_y_pred_prob.append(y_pred_prob)\n",
    "        all_y_true.append(y_test)\n",
    "\n",
    "        # ROC\n",
    "        fpr, tpr, _ = roc_curve(y_test, y_pred_prob)\n",
    "        interp_tpr = np.interp(mean_fpr, fpr, tpr)\n",
    "        interp_tpr[0] = 0.0\n",
    "        tprs.append(interp_tpr)\n",
    "        auc_scores.append(auc(fpr, tpr))\n",
    "\n",
    "    print(\"\\nWyniki dla różnych wartości threshold:\")\n",
    "\n",
    "    # Zamiana na numpy array\n",
    "    all_y_true = np.concatenate(all_y_true)\n",
    "    all_y_pred_prob = np.concatenate(all_y_pred_prob)\n",
    "\n",
    "    for thresh in thresholds:\n",
    "        accuracies, f1s, precisions, recalls, specificities, mccs = [], [], [], [], [], []\n",
    "\n",
    "        start = 0\n",
    "        for i in range(folds):\n",
    "            # Oblicz indeks końcowy dla danego folda\n",
    "            fold_len = len(all_y_true) // folds\n",
    "            end = start + fold_len if i < folds - 1 else len(all_y_true)\n",
    "\n",
    "            y_true_fold = all_y_true[start:end]\n",
    "            y_prob_fold = all_y_pred_prob[start:end]\n",
    "            y_pred_fold = (y_prob_fold >= thresh).astype(int)\n",
    "\n",
    "            cm = confusion_matrix(y_true_fold, y_pred_fold)\n",
    "            tn, fp, fn, tp = cm.ravel()\n",
    "\n",
    "            acc = accuracy_score(y_true_fold, y_pred_fold)\n",
    "            f1 = f1_score(y_true_fold, y_pred_fold)\n",
    "            prec = precision_score(y_true_fold, y_pred_fold, zero_division=0)\n",
    "            rec = recall_score(y_true_fold, y_pred_fold)\n",
    "            spec = tn / (tn + fp) if (tn + fp) > 0 else 0\n",
    "            mcc = matthews_corrcoef(y_true_fold, y_pred_fold)\n",
    "\n",
    "            accuracies.append(acc)\n",
    "            f1s.append(f1)\n",
    "            precisions.append(prec)\n",
    "            recalls.append(rec)\n",
    "            specificities.append(spec)\n",
    "            mccs.append(mcc)\n",
    "\n",
    "            start = end\n",
    "\n",
    "        def mean_std_str(metric_list):\n",
    "            return f\"{np.mean(metric_list):.4f} ± {np.std(metric_list):.4f}\"\n",
    "\n",
    "        print(f\"\\nThreshold = {thresh}\")\n",
    "        print(f\"Accuracy:     {mean_std_str(accuracies)}\")\n",
    "        print(f\"F1:           {mean_std_str(f1s)}\")\n",
    "        print(f\"Precision:    {mean_std_str(precisions)}\")\n",
    "        print(f\"Sensitivity:  {mean_std_str(recalls)}\")\n",
    "        print(f\"Specificity:  {mean_std_str(specificities)}\")\n",
    "        print(f\"MCC:          {mean_std_str(mccs)}\")\n",
    "\n",
    "    mean_auc = np.mean(auc_scores)\n",
    "    print(f\"\\nŚredni AUC: {mean_auc:.4f}\")\n",
    "\n",
    "    # Średnia krzywa ROC\n",
    "    mean_tpr = np.mean(tprs, axis=0)\n",
    "    mean_tpr[-1] = 1.0\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(mean_fpr, mean_tpr, label=f'ROC (AUC = {mean_auc:.4f})')\n",
    "    plt.plot([0, 1], [0, 1], linestyle='--', color='gray')\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title('Średnia krzywa ROC (5-fold)')\n",
    "    plt.legend(loc='lower right')\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m284/284\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n",
      "\u001b[1m280/280\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 994us/step\n",
      "\u001b[1m287/287\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 999us/step\n",
      "\u001b[1m285/285\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 986us/step\n",
      "\u001b[1m286/286\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 975us/step\n",
      "\n",
      "Wyniki dla różnych wartości threshold:\n",
      "\n",
      "Threshold = 0.3\n",
      "Accuracy:     0.7952 ± 0.0212\n",
      "F1:           0.8500 ± 0.0118\n",
      "Precision:    0.7656 ± 0.0276\n",
      "Sensitivity:  0.9567 ± 0.0139\n",
      "Specificity:  0.5478 ± 0.0722\n",
      "MCC:          0.5762 ± 0.0388\n",
      "\n",
      "Threshold = 0.5\n",
      "Accuracy:     0.8146 ± 0.0094\n",
      "F1:           0.8517 ± 0.0065\n",
      "Precision:    0.8265 ± 0.0222\n",
      "Sensitivity:  0.8797 ± 0.0229\n",
      "Specificity:  0.7148 ± 0.0467\n",
      "MCC:          0.6084 ± 0.0220\n",
      "\n",
      "Threshold = 0.7\n",
      "Accuracy:     0.7940 ± 0.0128\n",
      "F1:           0.8180 ± 0.0123\n",
      "Precision:    0.8790 ± 0.0191\n",
      "Sensitivity:  0.7656 ± 0.0226\n",
      "Specificity:  0.8375 ± 0.0294\n",
      "MCC:          0.5910 ± 0.0264\n",
      "\n",
      "Średni AUC: 0.8808\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def custom_scheduler(epoch, lr):\n",
    "    if epoch < 5:\n",
    "        return lr\n",
    "    else:\n",
    "        return float(lr * tf.math.exp(-0.1))\n",
    "\n",
    "def build_model(input_dim):\n",
    "    model = models.Sequential([\n",
    "        layers.Input(shape=(input_dim,)),\n",
    "        layers.Dense(1024, activation='relu'), \n",
    "        layers.Dense(512, activation='relu'),\n",
    "        layers.Dense(256, activation='relu'),\n",
    "        layers.Dense(128, activation='relu'), \n",
    "        layers.Dense(1, activation='sigmoid') \n",
    "    ])\n",
    "    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "scheduler = LearningRateScheduler(custom_scheduler)\n",
    "evaluate_given_keras_model(build_model,thresholds=[0.3, 0.5, 0.7], scheduler=scheduler, epochs=10, batch_size=64)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.7144 ± 0.0110\n",
      "F1:           0.7932 ± 0.0069\n",
      "Precision:    0.7062 ± 0.0093\n",
      "Sensitivity:  0.9046 ± 0.0039\n",
      "Specificity:  0.4225 ± 0.0246\n"
     ]
    }
   ],
   "source": [
    "SVM = SVC(kernel='linear')\n",
    "evaluate_model_on_folds(SVM,scaler=\"inny\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:     0.7979 ± 0.0116\n",
      "F1:           0.8394 ± 0.0085\n",
      "Precision:    0.8091 ± 0.0135\n",
      "Sensitivity:  0.8721 ± 0.0095\n",
      "Specificity:  0.6841 ± 0.0270\n"
     ]
    }
   ],
   "source": [
    "from neo_ls_svm import NeoLSSVM\n",
    "\n",
    "model = NeoLSSVM()\n",
    "evaluate_model_on_folds(model,scaler=\"inny\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
